Section: New Results

Theory of Distributed Systems

An improved bound for random binary search trees with concurrent insertions

Participant : George Giakkoupis.

Recently, Aspnes and Ruppert (DISC 2016) defined the following simple random experiment to determine the impact of concurrency on the performance of binary search trees: $n$ randomly permuted keys arrive one at a time. When a new key arrives, it is first placed into a buffer of size $c$. Whenever the buffer is full, or when all keys have arrived, an adversary chooses one key from the buffer and inserts it into the binary search tree. The ability of the adversary to choose the next key to insert among $c$ buffered keys, models a distributed system, where up to $c$ processes try to insert keys concurrently. Aspnes and Ruppert showed that the expected average depth of nodes in the resulting tree is $O(logn+c)$ for a comparison-based adversary, which can only take the relative order of arrived keys into account. In work [25], we generalize and strengthen this result. In particular, we allow an adversary that knows the actual values of all keys that have arrived, and show that the resulting expected average node depth is $D_{avg}\left(n\right)+O\left(c\right)$, where $D_{avg}\left(n\right)=2ln\left(n\right)-Theta\left(1\right)$ is the expected average node depth of a random tree obtained in the standard unbuffered version of this experiment. Extending the bound by Aspnes and Ruppert to this stronger adversary model answers one of their open questions.

This work was done in collaboration with Philipp Woelfel (University of Calgary).

Acyclic strategy for silent self-stabilization in spanning forests

Participant : Anaïs Durand.

Self-stabilization is a general paradigm to enable the design of distributed systems tolerating any finite number of transient faults. Many self-stabilizing algorithms are designed using the same patterns. In [30] we formalize some of those design patterns to obtain general statements regarding both correctness and time complexity. Precisely, we study a class of algorithms devoted to networks endowed with a sense of direction describing a spanning forest whose characterization is a simple (i.e., quasi-syntactic) condition. We show that any algorithm of this class is (1) silent and self-stabilizing under the distributed unfair daemon (the weakest scheduling assumption in the considered model), and (2) has a stabilization time polynomial in moves and asymptotically optimal in rounds. Our condition mainly uses the concept of acyclic strategy, which is based on the notions of top-down and bottom-up actions. We have combined this formalization together with a notion of acyclic causality between actions and a last criteria called correct-alone (n.b., only this criteria is not syntactic) to obtain the notion of acyclic strategy. We show that any algorithm following an acyclic strategy reaches a terminal configuration in a polynomial number of moves, assuming a distributed unfair daemon. Hence, if its terminal configurations satisfy the specification, the algorithm is both silent and self-stabilizing. Unfortunately, we show that this condition is not sufficient to obtain an asymptotically optimal stabilization time in rounds. So, we enforce the acyclic strategy with the property of local mutual exclusivity to have an asymptotically optimal round complexity. We also propose a simple method to make any algorithm, that follows an acyclic strategy, locally mutually exclusive. This method has no overhead in moves. Finally, to show the versatility of our approach, we review works where our results apply.

This work was done in collaboration with Karine Altisen and Stéphane Devismes (VERIMAG, Université Grenoble Alpes).

Set agreement and renaming in the presence of contention-related crash failures

Participants : Anaïs Durand, Michel Raynal.

Given a predefined contention threshold $\lambda$, consider all executions in which process crashes are restricted to occur only when process contention is smaller than or equal to $\lambda$. If crashes occur after contention bypassed $\lambda$, there are no correctness guarantees (e.g., termination is not guaranteed). It is known that, when $\lambda =n-1$, consensus can be solved in an $n$-process asynchronous read/write system despite the crash of one process, thereby circumventing the well-known FLP impossibility result. Furthermore, it was shown that when $\lambda =n-k$ and $k\ge 2$ , $k$-set agreement can be solved despite the crash of $2k-2$ processes.

In work [33] we consider two types of process crash failures: $\lambda$-constrained crash failures (as previously defined), and classical crash failures (that we call any time failures). We present two algorithms suited to these types of failures. The first algorithm solves $k$-set agreement, where $k=m+f$, in the presence of $t=2m+f-1$ crash failures, $2m$ of them being $\left(n-k\right)$-constrained failures, and $\left(f-1\right)$ being any time failures. The second algorithm solves $(n+f)$-renaming in the presence of $t=m+f$ crash failures, $m$ of them being $\left(n-t-1\right)$-constrained failures, and $f$ being any time failures. It follows that the differentiation between $\lambda$-constrained crash failures and any time crash failures enlarges the space of executions in which the impossibility of $k$-set agreement and renaming in the presence of asynchrony and process crashes can be circumvented. In addition to its behavioral properties, both algorithms have a noteworthy first class property, namely, their simplicity.

This work was done in collaboration with Gadi Taubenfeld (IDC Herzliya).

Anonymous obstruction-free $(n,k)$-set agreement with $n-k+1$ atomic read/write registers

Participant : Michel Raynal.

The $k$-set agreement problem is a generalization of the consensus problem. Namely, assuming that each process proposes a value, every non-faulty process must decide one of the proposed values, under the constraint that at most $k$ different values are decided. This is a hard problem in the sense that it cannot be solved in a pure read/write asynchronous system, in which $k$ or more processes may crash. One way to sidestep this impossibility result consists in weakening the termination property, requiring only that a process decides if it executes alone during a long enough period of time. This is the well-known obstruction-freedom progress condition. Consider a system of $n$ anonymous asynchronous processes that communicate through atomic read/write registers, and such that any number of them may crash. In work [14] we address and solve the challenging open problem of designing an obstruction-free $k$-set agreement algorithm with only $(n-k+1)$ atomic registers. From a shared memory cost point of view, our algorithm is the best algorithm known to date, thereby establishing a new upper bound on the number of registers needed to solve this problem. For the consensus case ($k=1$), the proposed algorithm is up to an additive factor of 1 close to the best known lower bound. Further, the paper extends this algorithm to obtain an $x$-obstruction-free solution to the $k$-set agreement problem that employs $(n-k+x)$ atomic registers, as well as a space-optimal solution for the repeated version of $k$-set agreement. Using this last extension, we prove that $n$ registers are enough for every colorless task that is obstruction-free solvable with identifiers and any number of registers.

This work was done in collaboration with Zohir Bouzid and Pierre Sutra (CNRS).